/**
 * 场景树形结构管理器
 * 用于管理场景中的所有对象节点（3D模型、空节点等）
 * 支持父子关系、节点移动、层级管理
 */

import * as THREE from 'three';

/**
 * 树节点类
 * 表示场景中的一个对象（可以是3D模型或空节点）
 */
export class TreeNode {
    constructor(options = {}) {
        this.id = options.id || this.generateId();
        this.name = options.name || 'Untitled';
        this.type = options.type || 'empty'; // 'empty', 'model', 'group', 'mesh'
        this.object3D = options.object3D || null; // Three.js Object3D 引用
        this.userData = options.userData || {}; // 自定义数据
        
        // 树结构
        this.parent = null;
        this.children = [];
        
        // 可见性和激活状态
        this.visible = options.visible !== undefined ? options.visible : true;
        this.locked = options.locked || false; // 是否锁定（不可编辑）
        
        // 创建时间
        this.createdAt = new Date();
    }
    
    /**
     * 生成唯一ID
     */
    generateId() {
        return `node-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
    }
    
    /**
     * 添加子节点
     */
    addChild(child) {
        if (!(child instanceof TreeNode)) {
            console.error('❌ 子节点必须是 TreeNode 实例');
            return false;
        }
        
        // 如果子节点已经有父节点，先从原父节点移除
        if (child.parent) {
            child.parent.removeChild(child);
        }
        
        child.parent = this;
        this.children.push(child);
        
        // 如果有 Object3D，也要更新 Three.js 的父子关系
        if (this.object3D && child.object3D) {
            this.object3D.add(child.object3D);
        }
        
        return true;
    }
    
    /**
     * 移除子节点
     */
    removeChild(child) {
        const index = this.children.indexOf(child);
        if (index === -1) {
            console.warn('⚠️ 子节点不存在');
            return false;
        }
        
        this.children.splice(index, 1);
        child.parent = null;
        
        // 同时从 Three.js 场景中移除
        if (this.object3D && child.object3D) {
            this.object3D.remove(child.object3D);
        }
        
        return true;
    }
    
    /**
     * 移动到新的父节点
     */
    moveTo(newParent) {
        if (!(newParent instanceof TreeNode)) {
            console.error('❌ 新父节点必须是 TreeNode 实例');
            return false;
        }
        
        // 不能移动到自己的子节点
        if (this.isAncestorOf(newParent)) {
            console.error('❌ 不能移动到自己的子节点');
            return false;
        }
        
        return newParent.addChild(this);
    }
    
    /**
     * 检查是否是指定节点的祖先
     */
    isAncestorOf(node) {
        let current = node.parent;
        while (current) {
            if (current === this) return true;
            current = current.parent;
        }
        return false;
    }
    
    /**
     * 获取所有祖先节点（从父节点到根节点）
     */
    getAncestors() {
        const ancestors = [];
        let current = this.parent;
        while (current) {
            ancestors.push(current);
            current = current.parent;
        }
        return ancestors;
    }
    
    /**
     * 获取节点深度（距离根节点的层级）
     */
    getDepth() {
        let depth = 0;
        let current = this.parent;
        while (current) {
            depth++;
            current = current.parent;
        }
        return depth;
    }
    
    /**
     * 获取节点路径（从根到当前节点的完整路径）
     */
    getPath() {
        const path = [this.name];
        let current = this.parent;
        while (current) {
            path.unshift(current.name);
            current = current.parent;
        }
        return path.join(' / ');
    }
    
    /**
     * 遍历所有子节点（深度优先）
     */
    traverse(callback) {
        callback(this);
        this.children.forEach(child => child.traverse(callback));
    }
    
    /**
     * 设置可见性
     */
    setVisible(visible) {
        this.visible = visible;
        if (this.object3D) {
            this.object3D.visible = visible;
        }
        // 递归设置所有子节点
        this.children.forEach(child => child.setVisible(visible));
    }
    
    /**
     * 切换可见性
     */
    toggleVisible() {
        this.setVisible(!this.visible);
    }
    
    /**
     * 导出为JSON
     */
    toJSON() {
        return {
            id: this.id,
            name: this.name,
            type: this.type,
            visible: this.visible,
            locked: this.locked,
            userData: this.userData,
            children: this.children.map(child => child.toJSON())
        };
    }
    
    /**
     * 销毁节点（释放资源）
     */
    dispose() {
        // 先销毁所有子节点
        [...this.children].forEach(child => child.dispose());
        
        // 从父节点移除
        if (this.parent) {
            this.parent.removeChild(this);
        }
        
        // 释放 Three.js 对象
        if (this.object3D) {
            // 释放几何体和材质
            if (this.object3D.geometry) {
                this.object3D.geometry.dispose();
            }
            if (this.object3D.material) {
                if (Array.isArray(this.object3D.material)) {
                    this.object3D.material.forEach(m => m.dispose());
                } else {
                    this.object3D.material.dispose();
                }
            }
        }
        
        this.object3D = null;
        this.parent = null;
        this.children = [];
    }
}

/**
 * 场景树管理器
 * 管理整个场景的树形结构
 */
export class SceneTreeManager {
    constructor(scene) {
        this.scene = scene; // Three.js Scene 引用
        this.root = new TreeNode({
            id: 'root',
            name: 'Scene Root',
            type: 'root',
            object3D: scene
        });
        
        this.nodesMap = new Map(); // id -> TreeNode 快速查找
        this.nodesMap.set('root', this.root);
        
        this.selectedNode = null; // 当前选中的节点
        this.eventCallbacks = {}; // 事件回调
    }
    
    /**
     * 添加节点到场景
     */
    addNode(options, parentId = 'root') {
        const parent = this.nodesMap.get(parentId);
        if (!parent) {
            console.error(`❌ 父节点不存在: ${parentId}`);
            return null;
        }
        
        const node = new TreeNode(options);
        parent.addChild(node);
        this.nodesMap.set(node.id, node);
        
        console.log(`✅ 节点已添加: ${node.name} (${node.type})`);
        this.emit('nodeAdded', { node, parent });
        
        return node;
    }
    
    /**
     * 从3D对象创建节点
     */
    addNodeFromObject3D(object3D, name, parentId = 'root') {
        const type = this.getObject3DType(object3D);
        
        return this.addNode({
            name: name || object3D.name || `${type}-${Date.now()}`,
            type: type,
            object3D: object3D,
            userData: { ...object3D.userData }
        }, parentId);
    }
    
    /**
     * 判断 Object3D 的类型
     */
    getObject3DType(object3D) {
        if (object3D.isMesh) return 'mesh';
        if (object3D.isGroup) return 'group';
        if (object3D.isLight) return 'light';
        if (object3D.isCamera) return 'camera';
        return 'object';
    }
    
    /**
     * 移除节点
     */
    removeNode(nodeId) {
        const node = this.nodesMap.get(nodeId);
        if (!node) {
            console.error(`❌ 节点不存在: ${nodeId}`);
            return false;
        }
        
        if (node === this.root) {
            console.error('❌ 不能删除根节点');
            return false;
        }
        
        // 递归删除所有子节点的映射
        node.traverse(n => {
            this.nodesMap.delete(n.id);
        });
        
        const parent = node.parent;
        node.dispose();
        
        console.log(`✅ 节点已删除: ${node.name}`);
        this.emit('nodeRemoved', { node, parent });
        
        return true;
    }
    
    /**
     * 移动节点到新父节点
     */
    moveNode(nodeId, newParentId, index = -1) {
        const node = this.nodesMap.get(nodeId);
        const newParent = this.nodesMap.get(newParentId);
        
        if (!node || !newParent) {
            console.error('❌ 节点或父节点不存在');
            return false;
        }
        
        if (node === this.root) {
            console.error('❌ 不能移动根节点');
            return false;
        }
        
        const oldParent = node.parent;
        const success = node.moveTo(newParent);
        
        if (success) {
            // 如果指定了索引，调整顺序
            if (index >= 0 && index < newParent.children.length) {
                const currentIndex = newParent.children.indexOf(node);
                if (currentIndex !== -1) {
                    newParent.children.splice(currentIndex, 1);
                    newParent.children.splice(index, 0, node);
                }
            }
            
            console.log(`✅ 节点已移动: ${node.name} → ${newParent.name}`);
            this.emit('nodeMoved', { node, oldParent, newParent });
        }
        
        return success;
    }
    
    /**
     * 根据ID查找节点
     */
    findNodeById(id) {
        return this.nodesMap.get(id) || null;
    }
    
    /**
     * 根据名称查找节点（返回第一个匹配的）
     */
    findNodeByName(name) {
        for (const node of this.nodesMap.values()) {
            if (node.name === name) return node;
        }
        return null;
    }
    
    /**
     * 根据类型查找所有节点
     */
    findNodesByType(type) {
        const nodes = [];
        for (const node of this.nodesMap.values()) {
            if (node.type === type) nodes.push(node);
        }
        return nodes;
    }
    
    /**
     * 根据 Object3D 查找节点
     */
    findNodeByObject3D(object3D) {
        for (const node of this.nodesMap.values()) {
            if (node.object3D === object3D) return node;
        }
        return null;
    }
    
    /**
     * 选中节点
     */
    selectNode(nodeId) {
        const node = this.nodesMap.get(nodeId);
        if (!node) {
            console.warn(`⚠️ 节点不存在: ${nodeId}`);
            return false;
        }
        
        const previousNode = this.selectedNode;
        this.selectedNode = node;
        
        this.emit('nodeSelected', { node, previousNode });
        console.log(`📍 节点已选中: ${node.name}`);
        
        return true;
    }
    
    /**
     * 取消选中
     */
    deselectNode() {
        const previousNode = this.selectedNode;
        this.selectedNode = null;
        this.emit('nodeDeselected', { previousNode });
    }
    
    /**
     * 获取所有节点（扁平化）
     */
    getAllNodes() {
        return Array.from(this.nodesMap.values());
    }
    
    /**
     * 获取节点总数
     */
    getNodeCount() {
        return this.nodesMap.size;
    }
    
    /**
     * 遍历所有节点
     */
    traverse(callback) {
        this.root.traverse(callback);
    }
    
    /**
     * 导出树结构为JSON
     */
    toJSON() {
        return {
            root: this.root.toJSON(),
            nodeCount: this.getNodeCount(),
            exportedAt: new Date().toISOString()
        };
    }
    
    /**
     * 从JSON加载树结构
     */
    fromJSON(json, scene) {
        // 清空当前树
        this.clear();
        
        // 重建树结构
        const buildTree = (nodeData, parent) => {
            const node = new TreeNode({
                id: nodeData.id,
                name: nodeData.name,
                type: nodeData.type,
                visible: nodeData.visible,
                locked: nodeData.locked,
                userData: nodeData.userData
            });
            
            parent.addChild(node);
            this.nodesMap.set(node.id, node);
            
            // 递归构建子节点
            if (nodeData.children) {
                nodeData.children.forEach(childData => {
                    buildTree(childData, node);
                });
            }
        };
        
        if (json.root && json.root.children) {
            json.root.children.forEach(childData => {
                buildTree(childData, this.root);
            });
        }
        
        console.log(`✅ 已从JSON加载 ${this.getNodeCount()} 个节点`);
    }
    
    /**
     * 清空所有节点（保留根节点）
     */
    clear() {
        [...this.root.children].forEach(child => {
            this.removeNode(child.id);
        });
        this.selectedNode = null;
        console.log('✅ 场景树已清空');
    }
    
    /**
     * 事件系统 - 注册事件
     */
    on(event, callback) {
        if (!this.eventCallbacks[event]) {
            this.eventCallbacks[event] = [];
        }
        this.eventCallbacks[event].push(callback);
    }
    
    /**
     * 事件系统 - 触发事件
     */
    emit(event, data) {
        if (this.eventCallbacks[event]) {
            this.eventCallbacks[event].forEach(callback => {
                try {
                    callback(data);
                } catch (error) {
                    console.error(`❌ 事件回调错误 [${event}]:`, error);
                }
            });
        }
    }
    
    /**
     * 打印树结构（调试用）
     */
    printTree(node = this.root, indent = '') {
        console.log(`${indent}├─ ${node.name} (${node.type}) [${node.id}]`);
        node.children.forEach((child, index) => {
            const isLast = index === node.children.length - 1;
            this.printTree(child, indent + (isLast ? '   ' : '│  '));
        });
    }
    
    /**
     * 获取树结构的文本表示
     */
    getTreeString(node = this.root, indent = '', isLast = true) {
        const prefix = isLast ? '└── ' : '├── ';
        const childIndent = indent + (isLast ? '    ' : '│   ');
        
        let result = indent + prefix + `${node.name} (${node.type})\n`;
        
        node.children.forEach((child, index) => {
            const childIsLast = index === node.children.length - 1;
            result += this.getTreeString(child, childIndent, childIsLast);
        });
        
        return result;
    }
}

/**
 * 导出默认实例创建函数
 */
export function createSceneTreeManager(scene) {
    return new SceneTreeManager(scene);
}

